home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d13 / ptv2n1.arc / TYPESALL.CPP < prev    next >
C/C++ Source or Header  |  1991-03-26  |  5KB  |  122 lines
  1. #include <string.h>                        
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <values.h>
  5. #include <typesall.h>
  6.  
  7.  
  8. ///////Code for the value classes
  9. //The code for each function is kept in parallel so we can
  10. //take advantage of the symmetry across the types
  11.  
  12. //Constructors
  13. char* invalid="invalid";//Address used for <namptr> to indicate error
  14. value::value(){namptr=NULL;}
  15. value::value(char* namestr){
  16.     namptr=namestr? strdup(namestr):NULL;
  17.     if(!namptr) namptr=invalid;}
  18. ival::ival(char* namestr, int val):value(namestr){data=val;}
  19. lval::lval(char* namestr, long val):value(namestr){data=val;}
  20. fval::fval(char* namestr, float val):value(namestr){data=val;}
  21. dval::dval(char* namestr, double val):value(namestr){data=val;}
  22. ldval::ldval(char* namestr, long double val):value(namestr){data=val;}
  23. sval::sval(char* namestr, char* val):value(namestr){
  24.     data=val? strdup(val):NULL; 
  25.     if(!data) namptr=invalid;}
  26.  
  27. //destructors
  28. value::~value(){if(namptr!=invalid) delete namptr;}
  29. sval::~sval(){delete data;}
  30.  
  31. //characteristics
  32. value::valid(){return namptr!=invalid;}//compare address, NOT string
  33.  
  34. datatype value::type(){return EMPTY;}
  35. datatype ival::type(){return INT;}
  36. datatype lval::type(){return LONG;}
  37. datatype fval::type(){return FLOAT;}
  38. datatype dval::type(){return DOUBLE;}
  39. datatype ldval::type(){return LDOUBLE;}
  40. datatype sval::type(){return STRING;}
  41.  
  42. const char* value::typename(){return "EMPTY";}
  43. const char* ival::typename(){return "INT";}
  44. const char* lval::typename(){return "LONG";}
  45. const char* fval::typename(){return "FLOAT";}
  46. const char* dval::typename(){return "DOUBLE";}
  47. const char* ldval::typename(){return "LDOUBLE";}
  48. const char* sval::typename(){return "STRING";}
  49.  
  50. //overloaded functions required for tests below
  51. inline long absval(long D){return (D>=0)? D:-D;}
  52. inline float absval(float D){return (D>=0)? D:-D;}
  53. inline double absval(double D){return (D>=0)? D:-D;}
  54. inline long double absval(long double D){return (D>=0)? D:-D;}
  55.  
  56. //return value as specified variable type
  57. //signed integer - returns zero if conversion not possible
  58. int value::asint(){return 0;};
  59. int ival::asint(){return data;}
  60. int lval::asint(){return (absval(data)<=MAXINT)?data:0;}
  61. int fval::asint(){return (absval(data)<=MAXINT)?data:0;}
  62. int dval::asint(){return (absval(data)<=MAXINT)?data:0;}
  63. int ldval::asint(){return (absval(data)<=MAXINT)?data:0;}
  64. int sval::asint(){return atoi(data);}
  65.  
  66. //signed long - returns zero if conversion not possible
  67. long value::aslong(){return 0;};
  68. long ival::aslong(){return data;}
  69. long lval::aslong(){return data;}
  70. long fval::aslong(){return (absval(data)<=MAXLONG)?data:0;}
  71. long dval::aslong(){return (absval(data)<=MAXLONG)?data:0;}
  72. long ldval::aslong(){return (absval(data)<=MAXLONG)?data:0;}
  73. long sval::aslong(){return atol(data);}
  74.  
  75. //range evaluation functions to check whether conversions will "fit"
  76. inline int floatsize(double D){
  77.     double absD=absval(D); return absD<MAXFLOAT && absD>MINFLOAT;}
  78. inline int floatsize(long double D){
  79.     long double absD=absval(D); return absD<=MAXFLOAT && absD>=MINFLOAT;}
  80. inline int doublesize(long double D){
  81.     long double absD=absval(D); return (absD<=MAXDOUBLE && absD>=MINDOUBLE);}
  82.  
  83. //float - returns zero if conversion not possible
  84. float value::asfloat(){return 0;};
  85. float ival::asfloat(){return data;}
  86. float lval::asfloat(){return data;}
  87. float fval::asfloat(){return data;}
  88. float dval::asfloat(){return floatsize(data)? data:0;}
  89. float ldval::asfloat(){return floatsize(data)? data:0;}
  90. float sval::asfloat(){float dbuf=atof(data);    return floatsize(dbuf)? dbuf:0;}
  91.  
  92. //double - returns zero if conversion not possible
  93. double value::asdouble(){return 0;};
  94. double ival::asdouble(){return data;}
  95. double lval::asdouble(){return data;}
  96. double fval::asdouble(){return data;}
  97. double dval::asdouble(){return data;}
  98. double ldval::asdouble(){return doublesize(data)? data:0;}
  99. double sval::asdouble(){return atof(data);}
  100.  
  101. //long double - returns zero if conversion not possible
  102. long double value::asldouble(){return 0;};
  103. long double ival::asldouble(){return data;}
  104. long double lval::asldouble(){return data;}
  105. long double fval::asldouble(){return data;}
  106. long double dval::asldouble(){return data;}
  107. long double ldval::asldouble(){return data;}
  108. long double sval::asldouble(){
  109.     long double dbuf; 
  110.     int valid=sscanf(data,"%Lg",&dbuf);    
  111.     return valid? dbuf:0;}
  112.  
  113. //string - re-uses same buffer at each call
  114. static char valbuf[40];
  115. const char* value::asstring(){return typename();}
  116. const char* ival::asstring(){return itoa(data,valbuf,10);}
  117. const char* lval::asstring(){return ltoa(data,valbuf,10);}
  118. const char* fval::asstring(){sprintf(valbuf,"%9.7g",data); return valbuf;}
  119. const char* dval::asstring(){sprintf(valbuf,"%17.15lg",data); return valbuf;}
  120. const char* ldval::asstring(){sprintf(valbuf,"%21.19Lg",data); return valbuf;}
  121. const char* sval::asstring(){return data;}
  122.